package matriceTest;

import static org.junit.Assert.*;
import jeuDeLaVie.Cellule;
import jeuDeLaVie.Liste;
import jeuDeLaVie.ListeInfini;

import matrice.CalculMatricielle;
import matrice.Matrice;
import matrice.Poid;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class CalculMatricielleTest {

	private Matrice matrice;
	private Liste listeA;
	private int[] univers={0,3,0,4};

	@Before
	public void setUp() throws Exception {
		listeA = new ListeInfini();
		listeA.getMaMatrice().add(new Cellule(1,1));
		listeA.getMaMatrice().add(new Cellule(1,2));
		listeA.getMaMatrice().add(new Cellule(1,3));
		listeA.getMaMatrice().add(new Cellule(2,1));
		listeA.setUnivers(univers);
		

		
	}

	@After
	public void tearDown() throws Exception {
	}

	@Test
	public final void testConvertion() {
		int taille=0;
		boolean b = true;
		matrice = CalculMatricielle.convertion(listeA);
		for( Poid p : matrice){
			if(p.getNbVoisin() != 1){
				fail("Mauvais nombre de voisin");
			}
			if(!p.getCellule().equals(listeA.getMaMatrice().get(taille))){
				fail("Mauvaise cellule");
			}
			taille++;
		}
		assertEquals(taille,listeA.getMaMatrice().size());
		assertTrue(b);
	}

	@Test
	public final void testBordure() {
		fail("erreur");
	}

	@Test
	public final void testFiltre() {
		matrice = CalculMatricielle.filtre(CalculMatricielle.translation(CalculMatricielle.convertion(listeA),2,2),listeA.getUnivers());
		int taille =0;
		for( Poid p : matrice){
			switch(taille){
				case 0: assertEquals(p.getCellule(),new Cellule(3,3));break;
				case 1: assertEquals(p.getCellule(),new Cellule(3,4));break;
			}
			if(p.getNbVoisin()>0){
				taille++;
			}
		}
		assertEquals(taille,2);
	}

	@Test
	public final void testTranslation() {
		int indice = 0 ;
		Cellule c = new Cellule(0,0);
		matrice = CalculMatricielle.translation(CalculMatricielle.convertion(listeA),1,1);
		for( Poid p : matrice){
			c.setAbs(listeA.getMaMatrice().get(indice).getAbs()+1);
			c.setOrd(listeA.getMaMatrice().get(indice).getOrd()+1);
			if(!p.getCellule().equals(c)){
				fail("Mauvaise translation");
			}
			if(p.getNbVoisin() != 1){
				fail("Erreur sur le voisinage");
			}
			indice++;
		}
	}

	@Test
	public final void testMultiplication() {
		int indice =0;
		matrice = CalculMatricielle.multiplication(CalculMatricielle.convertion(listeA), 9);
		for( Poid p : matrice){
			if(p.getNbVoisin()!= 9){
				fail("Mauvaise multiplication");
			}
			if(!p.getCellule().equals(listeA.getMaMatrice().get(indice))){
				fail("Mauvaise cellule");
			}
			indice++;
		}
		
	}

	@Test
	public final void testSomme() {
		Liste listeB = new ListeInfini();
		listeB.getMaMatrice().add(new Cellule(0,1));
		listeB.setUnivers(univers);
		
		Liste listeC = new ListeInfini();
		listeC.getMaMatrice().add(new Cellule(0,1));
		listeC.getMaMatrice().add(new Cellule(0,2));
		listeC.getMaMatrice().add(new Cellule(0,3));
		listeC.getMaMatrice().add(new Cellule(1,1));
		listeC.getMaMatrice().add(new Cellule(3,2));		
		listeC.setUnivers(univers);
		
		Liste listeD = new ListeInfini();
		listeD.getMaMatrice().add(new Cellule(1,1));
		listeD.getMaMatrice().add(new Cellule(1,2));
		listeD.getMaMatrice().add(new Cellule(1,3));
		listeD.getMaMatrice().add(new Cellule(2,1));
		listeD.setUnivers(univers);
		
		int taille = 0;
		matrice = CalculMatricielle.somme(CalculMatricielle.convertion(listeA), CalculMatricielle.convertion(listeB));
		for( Poid p : matrice){
			if(taille == 0){
				assertTrue(p.getCellule().equals(listeB.getMaMatrice().get(taille)));				
			}else{
				assertTrue(p.getCellule().equals(listeA.getMaMatrice().get(taille-1)));
			}
			if(p.getNbVoisin()!= 1){
				fail("Mauvaise somme");
			}
			taille++;
		}
		assertEquals(taille,5);
		
		taille = 0;
		matrice = CalculMatricielle.somme(CalculMatricielle.convertion(listeA), CalculMatricielle.convertion(listeC));
		for(Poid p : matrice){
			if(taille<=3){
				assertTrue(p.getCellule().equals(listeC.getMaMatrice().get(taille)));
			}else if(taille == 7){
				assertTrue(p.getCellule().equals(listeC.getMaMatrice().get(4)));
			}else{
				assertTrue(p.getCellule().equals(listeA.getMaMatrice().get(taille-3)));
			}
			
			taille++;
		}
		assertEquals(taille,8);
		
		taille = 0;
		matrice = CalculMatricielle.somme(CalculMatricielle.convertion(listeA), CalculMatricielle.convertion(listeD));
		for( Poid p : matrice){
			if(!p.getCellule().equals(listeA.getMaMatrice().get(taille))){
				fail("Mauvaise cellule");
			}
			if(p.getNbVoisin() != 2){
				fail("Mauvaise somme");
			}
			taille++;
		}
		assertEquals(taille,4);
	}

}
